Tipi Letterali di Template: Corrispondenza e Validazione di Modelli di Stringa in TypeScript

Il sistema di tipi di TypeScript è in continua evoluzione, offrendo agli sviluppatori strumenti più potenti per esprimere logiche complesse e garantire la sicurezza dei tipi. Una delle funzionalità più interessanti e versatili introdotte nelle versioni recenti sono i tipi letterali di template. Questi tipi consentono di manipolare le stringhe a livello di tipo, abilitando la corrispondenza e la validazione avanzata di modelli di stringa. Questo apre un mondo completamente nuovo di possibilità per la creazione di applicazioni più robuste e manutenibili.

Cosa Sono i Tipi Letterali di Template?

I tipi letterali di template sono una forma di tipo che viene costruita combinando tipi letterali di stringa e tipi unione, in modo simile a come funzionano i template literal in JavaScript. Tuttavia, invece di creare stringhe in fase di runtime, essi creano nuovi tipi basati su quelli esistenti.

Ecco un esempio di base:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

In questo esempio, `Greeting` è un tipo letterale di template che prende un tipo stringa `T` come input e restituisce un nuovo tipo che è la concatenazione di "Hello, ", `T`, e "!".

Corrispondenza di Modelli di Stringa di Base

I tipi letterali di template possono essere utilizzati per eseguire la corrispondenza di modelli di stringa di base. Questo consente di creare tipi che sono validi solo se corrispondono a un determinato modello.

Ad esempio, è possibile creare un tipo che accetta solo stringhe che iniziano con "prefix-":

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

In questo esempio, `PrefixedString` utilizza un tipo condizionale per verificare se la stringa di input `T` inizia con "prefix-". Se sì, il tipo è `T` stesso; altrimenti, è `never`. `never` è un tipo speciale in TypeScript che rappresenta il tipo di valori che non si verificano mai, escludendo efficacemente la stringa non valida.

Estrazione di Parti di una Stringa

I tipi letterali di template possono anche essere utilizzati per estrarre parti di una stringa. Questo è particolarmente utile quando è necessario analizzare i dati da stringhe e convertirli in tipi diversi.

Supponiamo di avere una stringa che rappresenta una coordinata nel formato "x:10,y:20". È possibile utilizzare i tipi letterali di template per estrarre i valori x e y:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

In questo esempio, `ExtractX` e `ExtractY` utilizzano la parola chiave `infer` per catturare le parti della stringa che corrispondono al tipo `number`. `infer` consente di estrarre un tipo da una corrispondenza di modello. I tipi catturati vengono quindi utilizzati come tipo di ritorno del tipo condizionale.

Validazione Avanzata delle Stringhe

I tipi letterali di template possono essere combinati con altre funzionalità di TypeScript, come i tipi unione e i tipi condizionali, per eseguire una validazione avanzata delle stringhe. Questo consente di creare tipi che applicano regole complesse sulla struttura e il contenuto delle stringhe.

Ad esempio, è possibile creare un tipo che valida le stringhe di data ISO 8601:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

Qui, `Year`, `Month` e `Day` sono definiti utilizzando tipi letterali di template per rappresentare i formati validi per ciascuna parte della data. `ISODate` combina quindi questi tipi per creare un tipo che rappresenta una stringa di data ISO 8601 valida. L'esempio dimostra anche come questo tipo possa essere utilizzato per imporre la formattazione dei dati in una funzione, impedendo il passaggio di formati di data errati. Ciò migliora l'affidabilità del codice e previene errori di runtime causati da input non validi.

Casi d'Uso Reali

I tipi letterali di template possono essere utilizzati in una varietà di scenari del mondo reale. Ecco alcuni esempi:

• Validazione di Moduli: È possibile utilizzare i tipi letterali di template per validare il formato degli input dei moduli, come indirizzi email, numeri di telefono e codici postali.
• Validazione di Richieste API: È possibile utilizzare i tipi letterali di template per validare la struttura dei payload delle richieste API, garantendo che siano conformi al formato previsto. Ad esempio, la validazione di un codice di valuta (es. "USD", "EUR", "GBP").
• Parsing di File di Configurazione: È possibile utilizzare i tipi letterali di template per analizzare i file di configurazione ed estrarre valori basati su modelli specifici. Si consideri la validazione dei percorsi dei file in un oggetto di configurazione.
• Enums Basati su Stringhe: È possibile creare enums basati su stringhe con validazione utilizzando i tipi letterali di template.

Esempio: Validazione di Codici di Valuta

Vediamo un esempio più dettagliato di validazione di codici di valuta. Vogliamo garantire che vengano utilizzati solo codici di valuta ISO 4217 validi nella nostra applicazione. Questi codici sono tipicamente tre lettere maiuscole.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase}${Uppercase}${Uppercase}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

Questo esempio dimostra come creare un tipo `CurrencyCode` che accetta solo stringhe composte da tre caratteri maiuscoli. Il secondo esempio, più fortemente tipizzato, mostra come limitare ulteriormente questo a un elenco predefinito di valute accettabili.

Esempio: Validazione dei Percorsi degli Endpoint API

Un altro caso d'uso è la validazione dei percorsi degli endpoint API. È possibile definire un tipo che rappresenta una struttura di endpoint API valida, garantendo che le richieste vengano effettuate a percorsi corretti. Questo è particolarmente utile nelle architetture a microservizi in cui più servizi potrebbero esporre API diverse.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

Questo consente di definire la struttura degli endpoint API in modo più preciso, prevenendo errori di battitura e garantendo la coerenza in tutta l'applicazione. Questo è un esempio di base; è possibile creare modelli più complessi per validare i parametri di query e altre parti dell'URL.

Benefici dell'Uso dei Tipi Letterali di Template

L'utilizzo dei tipi letterali di template per la corrispondenza e la validazione di modelli di stringa offre diversi vantaggi:

• Migliore Sicurezza dei Tipi: I tipi letterali di template consentono di imporre vincoli di tipo più rigidi sulle stringhe, riducendo il rischio di errori di runtime.
• Maggiore Leggibilità del Codice: I tipi letterali di template rendono il codice più leggibile esprimendo chiaramente il formato atteso delle stringhe.
• Aumento della Manutenibilità: I tipi letterali di template rendono il codice più manutenibile fornendo un'unica fonte di verità per le regole di validazione delle stringhe.
• Migliore Esperienza di Sviluppo: I tipi letterali di template offrono un migliore autocompletamento e messaggi di errore, migliorando l'esperienza complessiva dello sviluppatore.

Limitazioni

Sebbene i tipi letterali di template siano potenti, presentano anche alcune limitazioni:

• Complessità: I tipi letterali di template possono diventare complessi, specialmente quando si tratta di modelli intricati. È fondamentale bilanciare i benefici della sicurezza dei tipi con la manutenibilità del codice.
• Performance: I tipi letterali di template possono influire sulle prestazioni di compilazione, specialmente in progetti di grandi dimensioni. Questo perché TypeScript deve eseguire un controllo dei tipi più complesso.
• Supporto Limitato per le Espressioni Regolari: Sebbene i tipi letterali di template consentano la corrispondenza di modelli, non supportano l'intera gamma di funzionalità delle espressioni regolari. Per una validazione di stringhe altamente complessa, le espressioni regolari in fase di runtime potrebbero essere ancora necessarie accanto a queste costruzioni di tipo per una corretta sanificazione dell'input.

Migliori Pratiche

Ecco alcune delle migliori pratiche da tenere a mente quando si utilizzano i tipi letterali di template:

• Inizia Semplice: Inizia con modelli semplici e aumenta gradualmente la complessità secondo necessità.
• Usa Nomi Descrittivi: Usa nomi descrittivi per i tuoi tipi letterali di template per migliorare la leggibilità del codice.
• Documenta i Tuoi Tipi: Documenta i tuoi tipi letterali di template per spiegarne lo scopo e l'utilizzo.
• Testa Accuratamente: Testa accuratamente i tuoi tipi letterali di template per assicurarti che si comportino come previsto.
• Considera le Prestazioni: Sii consapevole dell'impatto dei tipi letterali di template sulle prestazioni di compilazione e ottimizza il tuo codice di conseguenza.

Conclusione

I tipi letterali di template sono una potente funzionalità di TypeScript che consente di eseguire manipolazione avanzata delle stringhe, corrispondenza di modelli e validazione a livello di tipo. Utilizzando i tipi letterali di template, è possibile creare applicazioni più robuste, manutenibili e sicure dal punto di vista dei tipi. Sebbene presentino alcune limitazioni, i benefici dell'utilizzo dei tipi letterali di template spesso superano gli svantaggi, rendendoli uno strumento prezioso nell'arsenale di ogni sviluppatore TypeScript. Man mano che il linguaggio TypeScript continua ad evolversi, comprendere e utilizzare queste funzionalità di tipo avanzate sarà cruciale per la costruzione di software di alta qualità. Ricorda di bilanciare la complessità con la leggibilità e di dare sempre priorità a test approfonditi.